#include "Framework_Cls.h"
EventDef* _evt_TestEvent0 = 0;
inline void TestEvent0_StaticInit()
{
	static EventDef evtDef("TestEvent0");
	_evt_TestEvent0 = &evtDef;
	evtDef.ID = EventDef::sEventArray.Add( &evtDef);
}
EventDef* _evt_TestEvent1 = 0;
inline void TestEvent1_StaticInit()
{
	static EventDef evtDef("TestEvent1");
	_evt_TestEvent1 = &evtDef;
	evtDef.ID = EventDef::sEventArray.Add( &evtDef);
	static EventArgDef arg0("id", Data_S32 );
	evtDef.ArgList = arg0.Next;
	static EventArgDef arg1("name", Data_DString );
	arg0.Next = arg1.Next;
}
////////////Enum LightTypes////////////
EnumDef* LightTypes_RTTI()
{
	static EnumDef enumDef( "LightTypes");
	return &enumDef;
}
inline void LightTypes_StaticInit()
{
	EnumDef* enumDef = LightTypes_RTTI();
	static EnumValue val0( "LT_POINT", (s32_t)Ogre::Light::LT_POINT);
	enumDef->ItemList = &val0;
	static EnumValue val1( "LT_SPOTLIGHT", (s32_t)Ogre::Light::LT_SPOTLIGHT);
	val0.Next = &val1;
}
////////////Enum ELayerBlendOperationEx////////////
EnumDef* ELayerBlendOperationEx_RTTI()
{
	static EnumDef enumDef( "ELayerBlendOperationEx");
	return &enumDef;
}
inline void ELayerBlendOperationEx_StaticInit()
{
	EnumDef* enumDef = ELayerBlendOperationEx_RTTI();
	static EnumValue val0( "LBX_SOURCE1", (s32_t)Ogre::LBX_SOURCE1);
	enumDef->ItemList = &val0;
	static EnumValue val1( "LBX_SOURCE2", (s32_t)Ogre::LBX_SOURCE2);
	val0.Next = &val1;
	static EnumValue val2( "LBX_MODULATE", (s32_t)Ogre::LBX_MODULATE);
	val1.Next = &val2;
	static EnumValue val3( "LBX_MODULATE_X2", (s32_t)Ogre::LBX_MODULATE_X2);
	val2.Next = &val3;
	static EnumValue val4( "LBX_MODULATE_X4", (s32_t)Ogre::LBX_MODULATE_X4);
	val3.Next = &val4;
	static EnumValue val5( "LBX_ADD", (s32_t)Ogre::LBX_ADD);
	val4.Next = &val5;
	static EnumValue val6( "LBX_ADD_SIGNED", (s32_t)Ogre::LBX_ADD_SIGNED);
	val5.Next = &val6;
	static EnumValue val7( "LBX_ADD_SMOOTH", (s32_t)Ogre::LBX_ADD_SMOOTH);
	val6.Next = &val7;
	static EnumValue val8( "LBX_SUBTRACT", (s32_t)Ogre::LBX_SUBTRACT);
	val7.Next = &val8;
	static EnumValue val9( "LBX_BLEND_DIFFUSE_ALPHA", (s32_t)Ogre::LBX_BLEND_DIFFUSE_ALPHA);
	val8.Next = &val9;
	static EnumValue val10( "LBX_BLEND_TEXTURE_ALPHA", (s32_t)Ogre::LBX_BLEND_TEXTURE_ALPHA);
	val9.Next = &val10;
	static EnumValue val11( "LBX_BLEND_CURRENT_ALPHA", (s32_t)Ogre::LBX_BLEND_CURRENT_ALPHA);
	val10.Next = &val11;
	static EnumValue val12( "LBX_BLEND_MANUAL", (s32_t)Ogre::LBX_BLEND_MANUAL);
	val11.Next = &val12;
	static EnumValue val13( "LBX_DOTPRODUCT", (s32_t)Ogre::LBX_DOTPRODUCT);
	val12.Next = &val13;
	static EnumValue val14( "LBX_BLEND_DIFFUSE_COLOUR", (s32_t)Ogre::LBX_BLEND_DIFFUSE_COLOUR);
	val13.Next = &val14;
}
////////////Enum ELayerBlendSource////////////
EnumDef* ELayerBlendSource_RTTI()
{
	static EnumDef enumDef( "ELayerBlendSource");
	return &enumDef;
}
inline void ELayerBlendSource_StaticInit()
{
	EnumDef* enumDef = ELayerBlendSource_RTTI();
	static EnumValue val0( "LBS_CURRENT", (s32_t)Ogre::LBS_CURRENT);
	enumDef->ItemList = &val0;
	static EnumValue val1( "LBS_TEXTURE", (s32_t)Ogre::LBS_TEXTURE);
	val0.Next = &val1;
	static EnumValue val2( "LBS_DIFFUSE", (s32_t)Ogre::LBS_DIFFUSE);
	val1.Next = &val2;
	static EnumValue val3( "LBS_SPECULAR", (s32_t)Ogre::LBS_SPECULAR);
	val2.Next = &val3;
	static EnumValue val4( "LBS_MANUAL", (s32_t)Ogre::LBS_MANUAL);
	val3.Next = &val4;
}
////////////Enum EFilterOptions////////////
EnumDef* EFilterOptions_RTTI()
{
	static EnumDef enumDef( "EFilterOptions");
	return &enumDef;
}
inline void EFilterOptions_StaticInit()
{
	EnumDef* enumDef = EFilterOptions_RTTI();
	static EnumValue val0( "FO_NONE", (s32_t)Ogre::FO_NONE);
	enumDef->ItemList = &val0;
	static EnumValue val1( "FO_POINT", (s32_t)Ogre::FO_POINT);
	val0.Next = &val1;
	static EnumValue val2( "FO_LINEAR", (s32_t)Ogre::FO_LINEAR);
	val1.Next = &val2;
	static EnumValue val3( "FO_ANISOTROPIC", (s32_t)Ogre::FO_ANISOTROPIC);
	val2.Next = &val3;
}
////////////Enum ETextureAddressingMode////////////
EnumDef* ETextureAddressingMode_RTTI()
{
	static EnumDef enumDef( "ETextureAddressingMode");
	return &enumDef;
}
inline void ETextureAddressingMode_StaticInit()
{
	EnumDef* enumDef = ETextureAddressingMode_RTTI();
	static EnumValue val0( "TAM_WRAP", (s32_t)Ogre::TextureUnitState::TAM_WRAP);
	enumDef->ItemList = &val0;
	static EnumValue val1( "TAM_MIRROR", (s32_t)Ogre::TextureUnitState::TAM_MIRROR);
	val0.Next = &val1;
	static EnumValue val2( "TAM_CLAMP", (s32_t)Ogre::TextureUnitState::TAM_CLAMP);
	val1.Next = &val2;
	static EnumValue val3( "TAM_BORDER", (s32_t)Ogre::TextureUnitState::TAM_BORDER);
	val2.Next = &val3;
}
////////////Enum ESceneBlendFunc////////////
EnumDef* ESceneBlendFunc_RTTI()
{
	static EnumDef enumDef( "ESceneBlendFunc");
	return &enumDef;
}
inline void ESceneBlendFunc_StaticInit()
{
	EnumDef* enumDef = ESceneBlendFunc_RTTI();
	static EnumValue val0( "SBF_ONE", (s32_t)Ogre::SBF_ONE);
	enumDef->ItemList = &val0;
	static EnumValue val1( "SBF_ZERO", (s32_t)Ogre::SBF_ZERO);
	val0.Next = &val1;
	static EnumValue val2( "SBF_DEST_COLOUR", (s32_t)Ogre::SBF_DEST_COLOUR);
	val1.Next = &val2;
	static EnumValue val3( "SBF_SOURCE_COLOUR", (s32_t)Ogre::SBF_SOURCE_COLOUR);
	val2.Next = &val3;
	static EnumValue val4( "SBF_ONE_MINUS_DEST_COLOUR", (s32_t)Ogre::SBF_ONE_MINUS_DEST_COLOUR);
	val3.Next = &val4;
	static EnumValue val5( "SBF_ONE_MINUS_SOURCE_COLOUR", (s32_t)Ogre::SBF_ONE_MINUS_SOURCE_COLOUR);
	val4.Next = &val5;
	static EnumValue val6( "SBF_DEST_ALPHA", (s32_t)Ogre::SBF_DEST_ALPHA);
	val5.Next = &val6;
	static EnumValue val7( "SBF_SOURCE_ALPHA", (s32_t)Ogre::SBF_SOURCE_ALPHA);
	val6.Next = &val7;
	static EnumValue val8( "SBF_ONE_MINUS_DEST_ALPHA", (s32_t)Ogre::SBF_ONE_MINUS_DEST_ALPHA);
	val7.Next = &val8;
	static EnumValue val9( "SBF_ONE_MINUS_SOURCE_ALPHA", (s32_t)Ogre::SBF_ONE_MINUS_SOURCE_ALPHA);
	val8.Next = &val9;
}
////////////Enum EFogMode////////////
EnumDef* EFogMode_RTTI()
{
	static EnumDef enumDef( "EFogMode");
	return &enumDef;
}
inline void EFogMode_StaticInit()
{
	EnumDef* enumDef = EFogMode_RTTI();
	static EnumValue val0( "FOG_NONE", (s32_t)Ogre::FOG_NONE);
	enumDef->ItemList = &val0;
	static EnumValue val1( "FOG_EXP", (s32_t)Ogre::FOG_EXP);
	val0.Next = &val1;
	static EnumValue val2( "FOG_EXP2", (s32_t)Ogre::FOG_EXP2);
	val1.Next = &val2;
	static EnumValue val3( "FOG_LINEAR", (s32_t)Ogre::FOG_LINEAR);
	val2.Next = &val3;
}
////////////Enum ECompareFunction////////////
EnumDef* ECompareFunction_RTTI()
{
	static EnumDef enumDef( "ECompareFunction");
	return &enumDef;
}
inline void ECompareFunction_StaticInit()
{
	EnumDef* enumDef = ECompareFunction_RTTI();
	static EnumValue val0( "CMPF_ALWAYS_FAIL", (s32_t)Ogre::CMPF_ALWAYS_FAIL);
	enumDef->ItemList = &val0;
	static EnumValue val1( "CMPF_ALWAYS_PASS", (s32_t)Ogre::CMPF_ALWAYS_PASS);
	val0.Next = &val1;
	static EnumValue val2( "CMPF_LESS", (s32_t)Ogre::CMPF_LESS);
	val1.Next = &val2;
	static EnumValue val3( "CMPF_LESS_EQUAL", (s32_t)Ogre::CMPF_LESS_EQUAL);
	val2.Next = &val3;
	static EnumValue val4( "CMPF_EQUAL", (s32_t)Ogre::CMPF_EQUAL);
	val3.Next = &val4;
	static EnumValue val5( "CMPF_NOT_EQUAL", (s32_t)Ogre::CMPF_NOT_EQUAL);
	val4.Next = &val5;
	static EnumValue val6( "CMPF_GREATER_EQUAL", (s32_t)Ogre::CMPF_GREATER_EQUAL);
	val5.Next = &val6;
	static EnumValue val7( "CMPF_GREATER", (s32_t)Ogre::CMPF_GREATER);
	val6.Next = &val7;
}
////////////Enum EVetrtexColorUsage////////////
EnumDef* EVetrtexColorUsage_RTTI()
{
	static EnumDef enumDef( "EVetrtexColorUsage");
	return &enumDef;
}
inline void EVetrtexColorUsage_StaticInit()
{
	EnumDef* enumDef = EVetrtexColorUsage_RTTI();
	static EnumValue val0( "TVC_NONE", (s32_t)Ogre::TVC_NONE);
	enumDef->ItemList = &val0;
	static EnumValue val1( "TVC_AMBIENT", (s32_t)Ogre::TVC_AMBIENT);
	val0.Next = &val1;
	static EnumValue val2( "TVC_DIFFUSE", (s32_t)Ogre::TVC_DIFFUSE);
	val1.Next = &val2;
	static EnumValue val3( "TVC_SPECULAR", (s32_t)Ogre::TVC_SPECULAR);
	val2.Next = &val3;
	static EnumValue val4( "TVC_EMISSIVE", (s32_t)Ogre::TVC_EMISSIVE);
	val3.Next = &val4;
}
////////////Enum ECullingMode////////////
EnumDef* ECullingMode_RTTI()
{
	static EnumDef enumDef( "ECullingMode");
	return &enumDef;
}
inline void ECullingMode_StaticInit()
{
	EnumDef* enumDef = ECullingMode_RTTI();
	static EnumValue val0( "CULL_NONE", (s32_t)Ogre::CULL_NONE);
	enumDef->ItemList = &val0;
	static EnumValue val1( "CULL_CLOCKWISE", (s32_t)Ogre::CULL_CLOCKWISE);
	val0.Next = &val1;
	static EnumValue val2( "CULL_ANTICLOCKWISE", (s32_t)Ogre::CULL_ANTICLOCKWISE);
	val1.Next = &val2;
}
////////////Enum EPartiDirection////////////
EnumDef* EPartiDirection_RTTI()
{
	static EnumDef enumDef( "EPartiDirection");
	return &enumDef;
}
inline void EPartiDirection_StaticInit()
{
	EnumDef* enumDef = EPartiDirection_RTTI();
	static EnumValue val0( "PD_Target", (s32_t)PD_Target);
	enumDef->ItemList = &val0;
	static EnumValue val1( "PD_BaseDir", (s32_t)PD_BaseDir);
	val0.Next = &val1;
	static EnumValue val2( "PD_Random", (s32_t)PD_Random);
	val1.Next = &val2;
	static EnumValue val3( "PD_UpUnitZ", (s32_t)PD_UpUnitZ);
	val2.Next = &val3;
}
EventDef* _evt_SequenceBegin = 0;
inline void SequenceBegin_StaticInit()
{
	static EventDef evtDef("SequenceBegin");
	_evt_SequenceBegin = &evtDef;
	evtDef.ID = EventDef::sEventArray.Add( &evtDef);
	static EventArgDef arg0("SeqActorID", Data_S32 );
	evtDef.ArgList = arg0.Next;
}
EventDef* _evt_SequenceEnd = 0;
inline void SequenceEnd_StaticInit()
{
	static EventDef evtDef("SequenceEnd");
	_evt_SequenceEnd = &evtDef;
	evtDef.ID = EventDef::sEventArray.Add( &evtDef);
	static EventArgDef arg0("SeqActorID", Data_S32 );
	evtDef.ArgList = arg0.Next;
}
////////////Enum ESoundFade////////////
EnumDef* ESoundFade_RTTI()
{
	static EnumDef enumDef( "ESoundFade");
	return &enumDef;
}
inline void ESoundFade_StaticInit()
{
	EnumDef* enumDef = ESoundFade_RTTI();
	static EnumValue val0( "SF_Ambient", (s32_t)SF_Ambient);
	enumDef->ItemList = &val0;
	static EnumValue val1( "SF_Ambient_Fade", (s32_t)SF_Ambient_Fade);
	val0.Next = &val1;
	static EnumValue val2( "SF_Point", (s32_t)SF_Point);
	val1.Next = &val2;
}
////////////class AComponent////////////
Base_NoCons(AComponent);
Begin_Cons_Init(AComponent)
Begin_Data_Init(AComponent)
ClassDef* clsDef = AComponent::RTTI();
clsDef->InitBegin();
EndObj;
////////////class Actor////////////
PropDef* Actor::_dataDef_mTickIsActive = 0;
PropDef* Actor::_dataDef_mTransPos = 0;
PropDef* Actor::_dataDef_mTransRot = 0;
PropDef* Actor::_dataDef_mTransScale = 0;
Base_NoCons(Actor);
Begin_Cons_Init(Actor)
,mActorID(-1)
,mTickIsActive(false)
,mAIDelete(false)
,mRootNode(0)
,mLevel(0)
Begin_Data_Init(Actor)
ClassDef* clsDef = Actor::RTTI();
clsDef->InitBegin();
{
	static PropDef def("Actor.ID", Data_S32, DataOffset( Actor, mActorID));
	def.EditorReadOnly = true;
	def.Editable = false;
	def.KismetVar = false;
	clsDef->_defProp( &def);
}
{
	static PropDef def("Tick.IsActive", Data_Bool, DataOffset( Actor, mTickIsActive));
	Actor::_dataDef_mTickIsActive = &def;
	clsDef->_defProp( &def);
}
{
	static PropDef def("Trans.Pos", Data_Vector3, DataOffset( Actor, mTransPos));
	Actor::_dataDef_mTransPos = &def;
	clsDef->_defProp( &def);
}
{
	static PropDef def("Trans.Rot", Data_Rot4, DataOffset( Actor, mTransRot));
	Actor::_dataDef_mTransRot = &def;
	clsDef->_defProp( &def);
}
{
	static PropDef def("Trans.Scale", Data_S32, DataOffset( Actor, mTransScale));
	Actor::_dataDef_mTransScale = &def;
	clsDef->_defProp( &def);
}
{
	static PropDef def("AI.Delete", Data_Bool, DataOffset( Actor, mAIDelete));
	def.Editable = false;
	def.IsSaveToDisk = false;
	clsDef->_defProp( &def);
}
EndObj;
////////////class ActorFactory////////////
void _invoke_ActorFactory_NewActor( Obj* obj, void* argList[])
{
	s32_t out0;
	((ActorFactory*)obj)->NewActor( out0);
	if( argList[0])
	{
		*(s32_t*)argList[0] = out0;
	}
}
void _invoke_ActorFactory_AddTemplate( Obj* obj, void* argList[])
{
	((ActorFactory*)obj)->AddTemplate( *((s32_t*)argList[0]));
}
void _invoke_ActorFactory_ClearAll( Obj* obj, void* argList[])
{
	((ActorFactory*)obj)->ClearAll();
}
Ins_NoCons(ActorFactory);
Begin_Cons_Init(ActorFactory)
Begin_Data_Init(ActorFactory)
ClassDef* clsDef = ActorFactory::RTTI();
clsDef->InitBegin();
{
	static FuncBind funcBind("NewActor", _invoke_ActorFactory_NewActor);
	clsDef->_bindFunc( &funcBind);
	static FuncArgDef arg0("id", Data_S32);
	arg0.IsOut = true;
	funcBind.ArgList = &arg0;
}
{
	static FuncBind funcBind("AddTemplate", _invoke_ActorFactory_AddTemplate);
	clsDef->_bindFunc( &funcBind);
	static FuncArgDef arg0("id", Data_S32);
	funcBind.ArgList = &arg0;
}
{
	static FuncBind funcBind("ClearAll", _invoke_ActorFactory_ClearAll);
	clsDef->_bindFunc( &funcBind);
}
EndObj;
////////////class Camera////////////
PropDef* Camera::_dataDef_mCtrlSync = 0;
Ins_NoCons(Camera);
Begin_Cons_Init(Camera)
Begin_Data_Init(Camera)
ClassDef* clsDef = Camera::RTTI();
clsDef->InitBegin();
{
	static PropDef def("Ctrl.Sync", Data_Bool, DataOffset( Camera, mCtrlSync));
	Camera::_dataDef_mCtrlSync = &def;
	clsDef->_defProp( &def);
}
EndObj;
////////////class Kismet////////////
Ins_NoCons(Kismet);
Begin_Cons_Init(Kismet)
,mCtrlActorID(-1)
Begin_Data_Init(Kismet)
ClassDef* clsDef = Kismet::RTTI();
clsDef->InitBegin();
EndObj;
////////////class Level////////////
Ins_NoCons(Level);
Begin_Cons_Init(Level)
Begin_Data_Init(Level)
ClassDef* clsDef = Level::RTTI();
clsDef->InitBegin();
{
	static PropDef def("Actor.List", Data_RefObj_Ptr, DataOffset( Level, mActorList));
	def.ClassType = Actor::RTTI();
	def.IsArray = true;
	clsDef->_defProp( &def);
}
EndObj;
////////////class LightActor////////////
Ins_NoCons(LightActor);
Begin_Cons_Init(LightActor)
,mLightType( Ogre::Light::LT_POINT)
,mLightIsStatic( true)
,mLightIsOn( true)
,mLightIsAffectDynamicObject( false)
,mColorDiffuse( 1.f,1.f,1.f,1.f)
,mColorSpecular( 1.f,1.f,1.f,1.f)
,mAttenuationRange( 10.f)
,mAttenuationConstant( 0.5f)
,mAttenuationLinear( 0.1f)
,mAttenuationQuadric( 0.2f)
,mAngleOutter( 30.f)
,mAngleInner( 30.f)
,mAngleFalloff( 1.f)
Begin_Data_Init(LightActor)
ClassDef* clsDef = LightActor::RTTI();
clsDef->InitBegin();
{
	static PropDef def("Light.Type", Data_Enum, DataOffset( LightActor, mLightType));
	def.EnumType = LightTypes_RTTI();
	def.KismetVar = false;
	clsDef->_defProp( &def);
}
{
	static PropDef def("Light.IsStatic", Data_Bool, DataOffset( LightActor, mLightIsStatic));
	def.KismetVar = false;
	clsDef->_defProp( &def);
}
{
	static PropDef def("Light.IsOn", Data_Bool, DataOffset( LightActor, mLightIsOn));
	clsDef->_defProp( &def);
}
{
	static PropDef def("Light.IsAffectDynamicObject", Data_Bool, DataOffset( LightActor, mLightIsAffectDynamicObject));
	clsDef->_defProp( &def);
}
{
	static PropDef def("Color.Diffuse", Data_Color4, DataOffset( LightActor, mColorDiffuse));
	def.KismetVar = false;
	clsDef->_defProp( &def);
}
{
	static PropDef def("Color.Specular", Data_Color4, DataOffset( LightActor, mColorSpecular));
	def.KismetVar = false;
	clsDef->_defProp( &def);
}
{
	static PropDef def("Attenuation.Range", Data_F32, DataOffset( LightActor, mAttenuationRange));
	def.KismetVar = false;
	clsDef->_defProp( &def);
}
{
	static PropDef def("Attenuation.Constant", Data_F32, DataOffset( LightActor, mAttenuationConstant));
	def.KismetVar = false;
	clsDef->_defProp( &def);
}
{
	static PropDef def("Attenuation.Linear", Data_F32, DataOffset( LightActor, mAttenuationLinear));
	def.KismetVar = false;
	clsDef->_defProp( &def);
}
{
	static PropDef def("Attenuation.Quadric", Data_F32, DataOffset( LightActor, mAttenuationQuadric));
	def.KismetVar = false;
	clsDef->_defProp( &def);
}
{
	static PropDef def("Angle.Outter", Data_F32, DataOffset( LightActor, mAngleOutter));
	def.KismetVar = false;
	clsDef->_defProp( &def);
}
{
	static PropDef def("Angle.Inner", Data_F32, DataOffset( LightActor, mAngleInner));
	def.KismetVar = false;
	clsDef->_defProp( &def);
}
{
	static PropDef def("Angle.Falloff", Data_F32, DataOffset( LightActor, mAngleFalloff));
	def.KismetVar = false;
	clsDef->_defProp( &def);
}
EndObj;
////////////class MTex////////////
Ins_NoCons(MTex);
Begin_Cons_Init(MTex)
Begin_Data_Init(MTex)
ClassDef* clsDef = MTex::RTTI();
clsDef->InitBegin();
{
	static PropDef def("Size.Width", Data_U32, DataOffset( MTex, mSizeWidth));
	def.Editable = false;
	clsDef->_defProp( &def);
}
{
	static PropDef def("Size.Height", Data_U32, DataOffset( MTex, mSizeHeight));
	def.Editable = false;
	clsDef->_defProp( &def);
}
EndObj;

////////////struct MTexUnit////////////
StructDef* MTexUnit::RTTI()
{
	static StructDef stcDef("MTexUnit", sizeof(MTexUnit));
	return &stcDef;
};
inline void MTexUnit_StaticInit()
{
	StructDef* structDef = MTexUnit::RTTI();
	{
		static PropDef def("Color.Opera", Data_Enum, DataOffset( MTexUnit, mColorOpera));
		def.EnumType = ELayerBlendOperationEx_RTTI();
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Color.Src1", Data_Enum, DataOffset( MTexUnit, mColorSrc1));
		def.EnumType = ELayerBlendSource_RTTI();
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Color.Src2", Data_Enum, DataOffset( MTexUnit, mColorSrc2));
		def.EnumType = ELayerBlendSource_RTTI();
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Color.Arg1", Data_F32, DataOffset( MTexUnit, mColorArg1));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Color.Arg2", Data_F32, DataOffset( MTexUnit, mColorArg2));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Color.Factor", Data_F32, DataOffset( MTexUnit, mColorFactor));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Alpha.Opera", Data_Enum, DataOffset( MTexUnit, mAlphaOpera));
		def.EnumType = ELayerBlendOperationEx_RTTI();
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Alpha.Src1", Data_Enum, DataOffset( MTexUnit, mAlphaSrc1));
		def.EnumType = ELayerBlendSource_RTTI();
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Alpha.Src2", Data_Enum, DataOffset( MTexUnit, mAlphaSrc2));
		def.EnumType = ELayerBlendSource_RTTI();
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Alpha.Arg1", Data_F32, DataOffset( MTexUnit, mAlphaArg1));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Alpha.Arg2", Data_F32, DataOffset( MTexUnit, mAlphaArg2));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Alpha.Factor", Data_F32, DataOffset( MTexUnit, mAlphaFactor));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Filter.Min", Data_Enum, DataOffset( MTexUnit, mFilterMin));
		def.EnumType = EFilterOptions_RTTI();
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Filter.Mag", Data_Enum, DataOffset( MTexUnit, mFilterMag));
		def.EnumType = EFilterOptions_RTTI();
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Filter.Mip", Data_Enum, DataOffset( MTexUnit, mFilterMip));
		def.EnumType = EFilterOptions_RTTI();
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Addressing.U", Data_Enum, DataOffset( MTexUnit, mAddressingU));
		def.EnumType = ETextureAddressingMode_RTTI();
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Addressing.V", Data_Enum, DataOffset( MTexUnit, mAddressingV));
		def.EnumType = ETextureAddressingMode_RTTI();
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Addressing.W", Data_Enum, DataOffset( MTexUnit, mAddressingW));
		def.EnumType = ETextureAddressingMode_RTTI();
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Scroll.U", Data_F32, DataOffset( MTexUnit, mScrollU));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Scroll.V", Data_F32, DataOffset( MTexUnit, mScrollV));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Scale.U", Data_F32, DataOffset( MTexUnit, mScaleU));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Scale.V", Data_F32, DataOffset( MTexUnit, mScaleV));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Coord.Index", Data_U32, DataOffset( MTexUnit, mCoordIndex));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Maps.TexMaps", Data_RefObj_Ptr, DataOffset( MTexUnit, mMapsTexMaps));
		def.ClassType = MTex::RTTI();
		def.IsArray = true;
		structDef->_defProp( &def);
	}
};

////////////struct MPass////////////
void _copy_MPassArray( void* dstArrayData, void* srcArrayData )
{
	TArray<MPass>& dstArray = *(TArray<MPass>*)dstArrayData;
	TArray<MPass>& srcArray = *(TArray<MPass>*)srcArrayData;
	dstArray.Clear( srcArray.Num());
	StructDef* stcDef = MPass::RTTI();
	for( int i = 0 ; i < srcArray.Num(); ++i)
	{
		MPass& newStc = dstArray.AddNew();
		stcDef->CopyStruct( &newStc, &srcArray[i]);
	}
}
void _resize_MPassArray( void* dstArrayData, s32_t num)
{
	TArray<MPass>& dstArray = *(TArray<MPass>*)dstArrayData;
	dstArray.Resize( num);
}
StructDef* MPass::RTTI()
{
	static StructDef stcDef("MPass", sizeof(MPass));
	return &stcDef;
};
inline void MPass_StaticInit()
{
	StructDef* structDef = MPass::RTTI();
	structDef->ArrayCopyFunc =  _copy_MPassArray;
	structDef->ArrayResizeFunc =  _resize_MPassArray;
	{
		static PropDef def("Color.Ambient", Data_Color4, DataOffset( MPass, mColorAmbient));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Color.Diffuse", Data_Color4, DataOffset( MPass, mColorDiffuse));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Color.Specular", Data_Color4, DataOffset( MPass, mColorSpecular));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Color.Emissive", Data_Color4, DataOffset( MPass, mColorEmissive));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Color.VCUsage", Data_Enum, DataOffset( MPass, mColorVCUsage));
		def.EnumType = EVetrtexColorUsage_RTTI();
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Blend.Source", Data_Enum, DataOffset( MPass, mBlendSource));
		def.EnumType = ESceneBlendFunc_RTTI();
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Blend.Dest", Data_Enum, DataOffset( MPass, mBlendDest));
		def.EnumType = ESceneBlendFunc_RTTI();
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Light.On", Data_Bool, DataOffset( MPass, mLightOn));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Depth.Check", Data_Bool, DataOffset( MPass, mDepthCheck));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Depth.Write", Data_Bool, DataOffset( MPass, mDepthWrite));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Depth.Func", Data_Enum, DataOffset( MPass, mDepthFunc));
		def.EnumType = ECompareFunction_RTTI();
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Depth.Constant", Data_F32, DataOffset( MPass, mDepthConstant));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Depth.SlopeScale", Data_F32, DataOffset( MPass, mDepthSlopeScale));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Depth.PerIteration", Data_F32, DataOffset( MPass, mDepthPerIteration));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Fog.Override", Data_Bool, DataOffset( MPass, mFogOverride));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Fog.FogMode", Data_Enum, DataOffset( MPass, mFogFogMode));
		def.EnumType = EFogMode_RTTI();
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Fog.Color", Data_Color4, DataOffset( MPass, mFogColor));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Fog.Start", Data_F32, DataOffset( MPass, mFogStart));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Fog.End", Data_F32, DataOffset( MPass, mFogEnd));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Fog.Density", Data_F32, DataOffset( MPass, mFogDensity));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("AlphaReject.Func", Data_Enum, DataOffset( MPass, mAlphaRejectFunc));
		def.EnumType = ECompareFunction_RTTI();
		structDef->_defProp( &def);
	}
	{
		static PropDef def("AlphaReject.Val", Data_S32, DataOffset( MPass, mAlphaRejectVal));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("AlphaReject.ToCoverageEnabled", Data_Bool, DataOffset( MPass, mAlphaRejectToCoverageEnabled));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("TextUnit.0", Data_Struct_Ins, DataOffset( MPass, mTextUnit0));
		def.StructType = MTexUnit::RTTI();
		structDef->_defProp( &def);
	}
	{
		static PropDef def("TextUnit.1", Data_Struct_Ins, DataOffset( MPass, mTextUnit1));
		def.StructType = MTexUnit::RTTI();
		structDef->_defProp( &def);
	}
};
////////////class MTech////////////
Ins_NoCons(MTech);
Begin_Cons_Init(MTech)
,mCullMode( Ogre::CULL_CLOCKWISE)
,mNeedBuild( true)
,mCoreTech( 0)
Begin_Data_Init(MTech)
ClassDef* clsDef = MTech::RTTI();
clsDef->InitBegin();
{
	static PropDef def("Cull.Mode", Data_Enum, DataOffset( MTech, mCullMode));
	def.EnumType = ECullingMode_RTTI();
	clsDef->_defProp( &def);
}
{
	static PropDef def("Pass.Passes", Data_Struct_Ins, DataOffset( MTech, mPassPasses));
	def.StructType = MPass::RTTI();
	def.IsArray = true;
	clsDef->_defProp( &def);
}
EndObj;

////////////struct SubMesh////////////
void _copy_SubMeshArray( void* dstArrayData, void* srcArrayData )
{
	TArray<SubMesh>& dstArray = *(TArray<SubMesh>*)dstArrayData;
	TArray<SubMesh>& srcArray = *(TArray<SubMesh>*)srcArrayData;
	dstArray.Clear( srcArray.Num());
	StructDef* stcDef = SubMesh::RTTI();
	for( int i = 0 ; i < srcArray.Num(); ++i)
	{
		SubMesh& newStc = dstArray.AddNew();
		stcDef->CopyStruct( &newStc, &srcArray[i]);
	}
}
void _resize_SubMeshArray( void* dstArrayData, s32_t num)
{
	TArray<SubMesh>& dstArray = *(TArray<SubMesh>*)dstArrayData;
	dstArray.Resize( num);
}
StructDef* SubMesh::RTTI()
{
	static StructDef stcDef("SubMesh", sizeof(SubMesh));
	return &stcDef;
};
inline void SubMesh_StaticInit()
{
	StructDef* structDef = SubMesh::RTTI();
	structDef->ArrayCopyFunc =  _copy_SubMeshArray;
	structDef->ArrayResizeFunc =  _resize_SubMeshArray;
	{
		static PropDef def("Setting.IsCollision", Data_Bool, DataOffset( SubMesh, mSettingIsCollision));
		structDef->_defProp( &def);
	}
	{
		static PropDef def("Setting.Visible", Data_Bool, DataOffset( SubMesh, mSettingVisible));
		structDef->_defProp( &def);
	}
};
////////////class Mesh////////////
Ins_NoCons(Mesh);
Begin_Cons_Init(Mesh)
,mLoaded( false)
Begin_Data_Init(Mesh)
ClassDef* clsDef = Mesh::RTTI();
clsDef->InitBegin();
{
	static PropDef def("Subs.SubAry", Data_Struct_Ins, DataOffset( Mesh, mSubsSubAry));
	def.StructType = SubMesh::RTTI();
	def.IsArray = true;
	clsDef->_defProp( &def);
}
EndObj;
////////////class PAffect////////////
Base_NoCons(PAffect);
Begin_Cons_Init(PAffect)
,mOwnerGrp( 0)
Begin_Data_Init(PAffect)
ClassDef* clsDef = PAffect::RTTI();
clsDef->InitBegin();
EndObj;
////////////class Particle////////////
Ins_NoCons(Particle);
Begin_Cons_Init(Particle)
Begin_Data_Init(Particle)
ClassDef* clsDef = Particle::RTTI();
clsDef->InitBegin();
EndObj;
////////////class PInit////////////
Base_NoCons(PInit);
Begin_Cons_Init(PInit)
,mOwnerGrp( 0)
Begin_Data_Init(PInit)
ClassDef* clsDef = PInit::RTTI();
clsDef->InitBegin();
EndObj;
////////////class PRender////////////
Base_NoCons(PRender);
Begin_Cons_Init(PRender)
,mOwnerGrp( 0)
Begin_Data_Init(PRender)
ClassDef* clsDef = PRender::RTTI();
clsDef->InitBegin();
EndObj;
////////////class PGroup////////////
Base_NoCons(PGroup);
Begin_Cons_Init(PGroup)
Begin_Data_Init(PGroup)
ClassDef* clsDef = PGroup::RTTI();
clsDef->InitBegin();
EndObj;
////////////class Sequence////////////
void _invoke_Sequence_Play( Obj* obj, void* argList[])
{
	((Sequence*)obj)->Play();
}
void _invoke_Sequence_Stop( Obj* obj, void* argList[])
{
	((Sequence*)obj)->Stop();
}
Ins_NoCons(Sequence);
Begin_Cons_Init(Sequence)
,mMoveLength( -1.f)
,mPlayedTime( -1.f)
Begin_Data_Init(Sequence)
ClassDef* clsDef = Sequence::RTTI();
clsDef->InitBegin();
{
	static FuncBind funcBind("Play", _invoke_Sequence_Play);
	clsDef->_bindFunc( &funcBind);
}
{
	static FuncBind funcBind("Stop", _invoke_Sequence_Stop);
	clsDef->_bindFunc( &funcBind);
}
EndObj;
////////////class SndBuffer////////////
Ins_NoCons(SndBuffer);
Begin_Cons_Init(SndBuffer)
,mPlayLoop( false)
,mBindBufID( null_index)
Begin_Data_Init(SndBuffer)
ClassDef* clsDef = SndBuffer::RTTI();
clsDef->InitBegin();
{
	static PropDef def("AL.Format", Data_S32, DataOffset( SndBuffer, mALFormat));
	clsDef->_defProp( &def);
}
{
	static PropDef def("AL.Frequency", Data_S32, DataOffset( SndBuffer, mALFrequency));
	clsDef->_defProp( &def);
}
{
	static PropDef def("Play.Loop", Data_Bool, DataOffset( SndBuffer, mPlayLoop));
	clsDef->_defProp( &def);
}
EndObj;
////////////class SndActor////////////
void _invoke_SndActor_Play( Obj* obj, void* argList[])
{
	((SndActor*)obj)->Play();
}
void _invoke_SndActor_Stop( Obj* obj, void* argList[])
{
	((SndActor*)obj)->Stop();
}
Ins_NoCons(SndActor);
Begin_Cons_Init(SndActor)
,mFadeVolume( 1.f)
,mFadeRadius( 10.f)
,mFadePow( 1.f)
,mFadeFade( SF_Point)
Begin_Data_Init(SndActor)
ClassDef* clsDef = SndActor::RTTI();
clsDef->InitBegin();
{
	static PropDef def("Src.Buffer", Data_RefObj_Ptr, DataOffset( SndActor, mSrcBuffer));
	def.ClassType = SndBuffer::RTTI();
	clsDef->_defProp( &def);
}
{
	static PropDef def("Fade.Volume", Data_F32, DataOffset( SndActor, mFadeVolume));
	clsDef->_defProp( &def);
}
{
	static PropDef def("Fade.Radius", Data_F32, DataOffset( SndActor, mFadeRadius));
	clsDef->_defProp( &def);
}
{
	static PropDef def("Fade.Pow", Data_F32, DataOffset( SndActor, mFadePow));
	clsDef->_defProp( &def);
}
{
	static PropDef def("Fade.Fade", Data_Enum, DataOffset( SndActor, mFadeFade));
	def.EnumType = ESoundFade_RTTI();
	clsDef->_defProp( &def);
}
{
	static FuncBind funcBind("Play", _invoke_SndActor_Play);
	clsDef->_bindFunc( &funcBind);
}
{
	static FuncBind funcBind("Stop", _invoke_SndActor_Stop);
	clsDef->_bindFunc( &funcBind);
}
EndObj;

////////////struct SubStaticModel////////////
void _copy_SubStaticModelArray( void* dstArrayData, void* srcArrayData )
{
	TArray<SubStaticModel>& dstArray = *(TArray<SubStaticModel>*)dstArrayData;
	TArray<SubStaticModel>& srcArray = *(TArray<SubStaticModel>*)srcArrayData;
	dstArray.Clear( srcArray.Num());
	StructDef* stcDef = SubStaticModel::RTTI();
	for( int i = 0 ; i < srcArray.Num(); ++i)
	{
		SubStaticModel& newStc = dstArray.AddNew();
		stcDef->CopyStruct( &newStc, &srcArray[i]);
	}
}
void _resize_SubStaticModelArray( void* dstArrayData, s32_t num)
{
	TArray<SubStaticModel>& dstArray = *(TArray<SubStaticModel>*)dstArrayData;
	dstArray.Resize( num);
}
StructDef* SubStaticModel::RTTI()
{
	static StructDef stcDef("SubStaticModel", sizeof(SubStaticModel));
	return &stcDef;
};
inline void SubStaticModel_StaticInit()
{
	StructDef* structDef = SubStaticModel::RTTI();
	structDef->ArrayCopyFunc =  _copy_SubStaticModelArray;
	structDef->ArrayResizeFunc =  _resize_SubStaticModelArray;
};
////////////class StaticModel////////////
Ins_NoCons(StaticModel);
Begin_Cons_Init(StaticModel)
Begin_Data_Init(StaticModel)
ClassDef* clsDef = StaticModel::RTTI();
clsDef->InitBegin();
EndObj;
////////////class TMesh////////////
Base_NoCons(TMesh);
Begin_Cons_Init(TMesh)
,mGeomIndex( -1)
Begin_Data_Init(TMesh)
ClassDef* clsDef = TMesh::RTTI();
clsDef->InitBegin();
{
	static PropDef def("Geom.Index", Data_S32, DataOffset( TMesh, mGeomIndex));
	clsDef->_defProp( &def);
}
EndObj;
////////////class TBatchGroup////////////
Ins_NoCons(TBatchGroup);
Begin_Cons_Init(TBatchGroup)
Begin_Data_Init(TBatchGroup)
ClassDef* clsDef = TBatchGroup::RTTI();
clsDef->InitBegin();
EndObj;
////////////class Terrain////////////
Ins_NoCons(Terrain);
Begin_Cons_Init(Terrain)
Begin_Data_Init(Terrain)
ClassDef* clsDef = Terrain::RTTI();
clsDef->InitBegin();
EndObj;
////////////class TTile////////////
Ins_NoCons(TTile);
Begin_Cons_Init(TTile)
Begin_Data_Init(TTile)
ClassDef* clsDef = TTile::RTTI();
clsDef->InitBegin();
EndObj;
////////////class World////////////
Ins_NoCons(World);
Begin_Cons_Init(World)
Begin_Data_Init(World)
ClassDef* clsDef = World::RTTI();
clsDef->InitBegin();
{
	static PropDef def("Sunlight.Dir", Data_Vector3, DataOffset( World, mSunlightDir));
	clsDef->_defProp( &def);
}
{
	static PropDef def("Sunlight.Diffuse", Data_Color4, DataOffset( World, mSunlightDiffuse));
	clsDef->_defProp( &def);
}
{
	static PropDef def("Sunlight.Ambient", Data_Color4, DataOffset( World, mSunlightAmbient));
	clsDef->_defProp( &def);
}
{
	static PropDef def("Fog.Color", Data_Color4, DataOffset( World, mFogColor));
	clsDef->_defProp( &def);
}
{
	static PropDef def("Fog.Begin", Data_F32, DataOffset( World, mFogBegin));
	clsDef->_defProp( &def);
}
{
	static PropDef def("Fog.End", Data_F32, DataOffset( World, mFogEnd));
	clsDef->_defProp( &def);
}
{
	static PropDef def("Fog.Density", Data_F32, DataOffset( World, mFogDensity));
	clsDef->_defProp( &def);
}
EndObj;
void Init_Framework_Class()
{
	TMesh_StaticInit();
	SndBuffer_StaticInit();
	PRender_StaticInit();
	PInit_StaticInit();
	MTech_StaticInit();
	MTex_StaticInit();
	AComponent_StaticInit();
	Actor_StaticInit();
	ActorFactory_StaticInit();
	Camera_StaticInit();
	TestEvent0_StaticInit();
	TestEvent1_StaticInit();
	Kismet_StaticInit();
	Level_StaticInit();
	LightTypes_StaticInit();
	LightActor_StaticInit();
	ELayerBlendOperationEx_StaticInit();
	ELayerBlendSource_StaticInit();
	EFilterOptions_StaticInit();
	ETextureAddressingMode_StaticInit();
	MTexUnit_StaticInit();
	ESceneBlendFunc_StaticInit();
	EFogMode_StaticInit();
	ECompareFunction_StaticInit();
	EVetrtexColorUsage_StaticInit();
	MPass_StaticInit();
	ECullingMode_StaticInit();
	SubMesh_StaticInit();
	Mesh_StaticInit();
	PAffect_StaticInit();
	Particle_StaticInit();
	EPartiDirection_StaticInit();
	PGroup_StaticInit();
	SequenceBegin_StaticInit();
	SequenceEnd_StaticInit();
	Sequence_StaticInit();
	ESoundFade_StaticInit();
	SndActor_StaticInit();
	SubStaticModel_StaticInit();
	StaticModel_StaticInit();
	TBatchGroup_StaticInit();
	Terrain_StaticInit();
	TTile_StaticInit();
	World_StaticInit();
}
